home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / gfx / show / svoUtah22.lha / svoUtahRLE / source / URT / lib / rle_raw_alc.c < prev    next >
C/C++ Source or Header  |  1990-08-02  |  4KB  |  158 lines
  1. /*
  2.  * This software is copyrighted as noted below.  It may be freely copied,
  3.  * modified, and redistributed, provided that the copyright notice is 
  4.  * preserved on all copies.
  5.  * 
  6.  * There is no warranty or other guarantee of fitness for this software,
  7.  * it is provided solely "as is".  Bug reports or fixes may be sent
  8.  * to the author, who may or may not act on them as he desires.
  9.  *
  10.  * You may not include this software in a program or other software product
  11.  * without supplying the source, or without informing the end-user that the 
  12.  * source is available for no extra charge.
  13.  *
  14.  * If you modify this software, you should include a notice giving the
  15.  * name of the person performing the modification, the date of modification,
  16.  * and the reason for such modification.
  17.  *
  18.  *  Modified at BRL 16-May-88 by Mike Muuss to avoid Alliant STDC desire
  19.  *  to have all "void" functions so declared.
  20.  */
  21. /* 
  22.  * rle_raw_alc.c - Allocate buffers for rle_getraw/rle_putraw.
  23.  * 
  24.  * Author:    Spencer W. Thomas
  25.  *         Computer Science Dept.
  26.  *         University of Utah
  27.  * Date:    Fri Nov 14 1986
  28.  * Copyright (c) 1986, Spencer W. Thomas
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <rle.h>
  33. #include <rle_raw.h>
  34.  
  35. #ifndef VOID_STAR
  36. extern char * malloc();
  37. #else
  38. extern void *malloc();
  39. #endif
  40. extern void free();
  41.  
  42. /*****************************************************************
  43.  * TAG( rle_raw_alloc )
  44.  * 
  45.  * Allocate buffer space for use by rle_getraw and rle_putraw.
  46.  * Inputs:
  47.  *     the_hdr:    Header structure for RLE file to be read or
  48.  *            written.
  49.  * Outputs:
  50.  *    scanp:        Pointer to pointer to created opcode buffer.
  51.  *     nrawp:        Pointer to pointer to created length buffer.
  52.  *            These pointers are adjusted for the alpha channel,
  53.  *            if present.
  54.  *    Returns 0 for success, -1 if malloc failed.
  55.  * Assumptions:
  56.  *     Since buffers are built to have as many slots as there are pixels
  57.  *    in the input scanline, it is assumed that no input scanline will
  58.  *    have more data elements than this.
  59.  * Algorithm:
  60.  *    Count number of channels actually used (check bitmap).
  61.  *     Allocate nchan*rowlength elements, allocate a buffer
  62.  *    to hold (ncolors+alpha) pointers.
  63.  *    Also allocate a buffer of ncolors+alpha
  64.  *    integers for the length buffer.
  65.  */
  66. int
  67. rle_raw_alloc( the_hdr, scanp, nrawp )
  68. rle_hdr *the_hdr;
  69. rle_op ***scanp;
  70. int **nrawp;
  71. {
  72.     rle_op ** scanbuf, * opbuf;
  73.     int rowlen, nchan = 0, i, ncol;
  74.  
  75.     rowlen = the_hdr->xmax - the_hdr->xmin + 1;
  76.     if ( the_hdr->alpha && RLE_BIT( *the_hdr, RLE_ALPHA ) )
  77.     nchan++;
  78.     for ( i = 0; i < the_hdr->ncolors; i++ )
  79.     if ( RLE_BIT( *the_hdr, i ) )
  80.          nchan++;
  81.  
  82.     ncol = the_hdr->ncolors + the_hdr->alpha;
  83.  
  84.     if ( (scanbuf = (rle_op **) malloc( ncol * sizeof(rle_op *) )) == 0 )
  85.     return -1;
  86.  
  87.     if ( (opbuf = (rle_op *)malloc( nchan * rowlen * sizeof(rle_op) )) == 0 )
  88.     {
  89.     free( scanbuf );
  90.     return -1;
  91.     }
  92.  
  93.     if ( (*nrawp = (int *)malloc( ncol * sizeof(int) )) == 0 )
  94.     {
  95.     free( scanbuf );
  96.     free( opbuf );
  97.     return -1;
  98.     }
  99.  
  100.     if ( the_hdr->alpha )
  101.     {
  102.     scanbuf++;
  103.     (*nrawp)++;
  104.     }
  105.  
  106.     for ( i = -the_hdr->alpha; i < the_hdr->ncolors; i++ )
  107.     if ( RLE_BIT( *the_hdr, i ) )
  108.     {
  109.         scanbuf[i] = opbuf;
  110.         opbuf += rowlen;
  111.     }
  112.     else
  113.         scanbuf[i] = 0;
  114.     *scanp = scanbuf;
  115.  
  116.     return 0;
  117. }
  118.  
  119.  
  120. /*****************************************************************
  121.  * TAG( rle_raw_free )
  122.  * 
  123.  * Free storage allocated by rle_raw_alloc().
  124.  * Inputs:
  125.  *     the_hdr:    Header structure as above.
  126.  *    scanp:        Pointer to scanbuf above.
  127.  *    nrawp:        Pointer to length buffer.
  128.  * Outputs:
  129.  *     Frees storage referenced by scanp and nrawp.
  130.  * Assumptions:
  131.  *     Storage was allocated by rle_raw_alloc, or by use of same
  132.  *    algorithm, at least.
  133.  * Algorithm:
  134.  *     free scanp[0], scanp, and nrawp.
  135.  */
  136. void
  137. rle_raw_free( the_hdr, scanp, nrawp )
  138. rle_hdr *the_hdr;
  139. rle_op **scanp;
  140. int *nrawp ;
  141. {
  142.     int i;
  143.  
  144.     if ( the_hdr->alpha )
  145.     {
  146.     scanp--;
  147.     nrawp--;
  148.     }
  149.     for ( i = 0; i < the_hdr->ncolors + the_hdr->alpha; i++ )
  150.     if ( scanp[i] != 0 )
  151.     {
  152.         free( (char *)scanp[i] );
  153.         break;
  154.     }
  155.     free( (char *)scanp );
  156.     free( (char *)nrawp );
  157. }
  158.